home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Web Server / PHP.EXE / pear / PHPDoc / xmlexporter / PhpdocXMLDocumentExporter.php < prev    next >
Encoding:
PHP Script  |  2001-02-18  |  14.2 KB  |  420 lines
  1. <?php
  2. /**
  3. * Base of the class and module exporter.
  4. * 
  5. * @version $Id: PhpdocXMLDocumentExporter.php,v 1.3 2001/02/18 16:53:00 uw Exp $
  6. */
  7. class PhpdocXMLDocumentExporter extends PhpdocXMLExporter {
  8.     
  9.     /**
  10.     * Mapping from internal result array index name to xml tag name.
  11.     *
  12.     * @var  array   $docTags
  13.     */
  14.     var $docTags = array(
  15.                             "desc"      => "description",
  16.                             "sdesc"     => "shortdescription",
  17.                             
  18.                             "version"   => "version",
  19.                             "since"     => "since",
  20.                             "version"   => "version",
  21.                             "deprec"    => "deprecated",
  22.                             "copyright" => "copyright",
  23.                             "exclude"   => "exclude",
  24.                             "brother"   => "brother",
  25.                             "magic"     => "magic"
  26.                         );
  27.  
  28.     /**
  29.     * Attributes of the <see> container.
  30.     *
  31.     * @var  array
  32.     */                                            
  33.     var $seeAttributes = array(
  34.                                 "type"  => "CDATA",
  35.                                 "group" => "CDATA"
  36.                             );
  37.     
  38.     /**
  39.     * Attributes of the <link> container.
  40.     *
  41.     * @var  array
  42.     */
  43.     var $linkAttributes = array( "url"    => "CDATA" );
  44.  
  45.     /**
  46.     * Attributes of the <author> container.
  47.     *
  48.     * @var  array
  49.     */                                                        
  50.     var $authorAttributes = array( "email"    => "CDATA" );
  51.                                                             
  52.     /**
  53.     * Attributes of <inherited> and <overriden> container.
  54.     *
  55.     * @var  array
  56.     */                                                            
  57.     var $inheritedOverridenAttributes = array(
  58.                                                 "src"   => "CDATA",
  59.                                                 "type"  => "CDATA"
  60.                                          );                                    
  61.  
  62.     /**
  63.     * Attributes of the <constant> container.
  64.     *
  65.     * @var  array
  66.     */                                                                                
  67.     var $constAttributes = array(
  68.                                     "name"      => "CDATA",
  69.                                     "undoc"     => "Boolean",
  70.                                     "access"    => "CDATA",
  71.                                     "case"      => "CDATA"
  72.                                 );
  73.  
  74.     /**
  75.     * Attribues of the <uses> container.
  76.     *
  77.     * @var  array
  78.     */                                                            
  79.     var $usesAttributes = array(
  80.                                 "type"  => "CDATA",
  81.                                 "file"  => "CDATA",
  82.                                 "undoc" => "Boolean"
  83.                         );
  84.                                                     
  85.     /**
  86.     * Attribues of the <function> container.
  87.     *
  88.     * @var  array
  89.     */                                                        
  90.     var $functionAttributes = array(
  91.                                     "name"      => "CDATA",
  92.                                     "undoc"     => "Boolean",
  93.                                     "access"    => "CDATA",
  94.                                     "abstract"  => "Boolean",
  95.                                     "static"    => "CDATA"
  96.                                 );
  97.  
  98.     /**
  99.     * Attributes of the <return> container.
  100.     *
  101.     * @var  array
  102.     */                                                                
  103.     var $returnAttributes = array( 
  104.                                     "name"  => "CDATA",
  105.                                     "type"  => "CDATA"
  106.                                 );            
  107.  
  108.     /**
  109.     * Attributes of the <global> container.
  110.     *
  111.     * @var  array
  112.     */                                                            
  113.     var $globalAttributes = array(
  114.                                     "name"  => "CDATA",
  115.                                     "type"  => "CDATA"
  116.                                 );            
  117.  
  118.     /**
  119.     * Attributes of the <param> container.
  120.     *
  121.     * @var  array
  122.     */                                                            
  123.     var $paramAttributes    = array(
  124.                                     "name"      => "CDATA",
  125.                                     "default"   => "CDATA",
  126.                                     "type"      => "CDATA",
  127.                                     "undoc"     => "Boolean"
  128.                                 );    
  129.     
  130.     /**
  131.     * Writes a <file> container.
  132.     *
  133.     * @param    string  $file   Filename
  134.     */
  135.     function filenameXML($file) {
  136.         $this->xmlwriter->addElement("file", $file);
  137.     } // end func filenameXML
  138.     
  139.     /**
  140.     * Adds all constants (define(), const) to the xml document.
  141.     *
  142.     * @param    array   Array of constants
  143.     * @return   boolean Returns false on failure otherwise true
  144.     */
  145.     function constsXML($consts) {
  146.         if (!is_array($consts) || 0 == count($consts)) 
  147.             return true;
  148.     
  149.         reset($consts);
  150.         while (list($k, $data)=each($consts)) {
  151.         
  152.             $attribs = $this->getAttributes($data, $this->constAttributes);
  153.             $this->xmlwriter->startElement("constant", (isset($data["value"])) ? $data["value"] : "", $attribs, false, true);
  154.             $this->docXML($data);
  155.             $this->xmlwriter->endElement("constant", true);
  156.             
  157.         }
  158.         
  159.         return true;
  160.     } // end func constsXML
  161.     
  162.     /**
  163.     * Adds a list of used files (include, require...) to the xml document.
  164.     * 
  165.     * @param    array
  166.     */
  167.     function usesXML($uses) {
  168.         if (!is_array($uses)) {
  169.             $this->err[] = new PhpdocError("No array given.", __FILE__, __LINE__);
  170.             return false;
  171.         }
  172.     
  173.         reset($uses);
  174.         while (list($k, $data) = each($uses)) {
  175.         
  176.             $attribs = $this->getAttributes($data, $this->usesAttributes);
  177.             $this->xmlwriter->startElement("uses", "", $attribs, false, true);
  178.             $this->docXML($data);    
  179.             $this->xmlwriter->endElement("uses", true);
  180.             
  181.         }
  182.         
  183.         return true;
  184.     } // end func usesXML
  185.     
  186.     /**
  187.     * Adds a list of functions to the xml file.
  188.     * 
  189.     * @param    array
  190.     */
  191.     function functionsXML($functions) {
  192.         if (!is_array($functions)) {
  193.             $this->err[] = new PhpdocError("No array given.", __FILE__, __LINE__);
  194.             return false;
  195.         }
  196.  
  197.         reset($functions);
  198.         while (list($k, $data) = each($functions)) {
  199.         
  200.             $attribs = $this->getAttributes($data, $this->functionAttributes);                    
  201.             $this->xmlwriter->startElement("function", "", $attribs, false, true);
  202.             $this->docXML($data);        
  203.             $this->xmlwriter->endElement("function", true);
  204.             
  205.         }
  206.                                                             
  207.     } // end functionsXML
  208.     
  209.     /**
  210.     * Adds a documentation block (author, links, see, params...) to the xml document
  211.     * 
  212.     * @param    sarray
  213.     */
  214.     function docXML($data) {
  215.         
  216.         $this->xmlwriter->startElement("doc", "", "", false, true);
  217.         
  218.         if (isset($data["link"]))
  219.             $this->linkXML($data["link"]);        
  220.         
  221.         if (isset($data["author"]))
  222.             $this->authorXML($data["author"]);
  223.             
  224.         if (isset($data["see"]))
  225.             $this->seeXML($data["see"]);
  226.             
  227.         if (isset($data["params"]))
  228.             $this->paramsXML($data["params"]);
  229.             
  230.         if (isset($data["return"]))
  231.             $this->returnXML($data["return"]);
  232.             
  233.         if (isset($data["throws"])) 
  234.             $this->throwsXML($data["throws"]);
  235.         
  236.         if (isset($data["global"]))
  237.             $this->globalsXML($data["global"]);
  238.  
  239.         if (isset($data["inherited"])) {
  240.             
  241.             
  242.             $attribs = array(
  243.                                 "src"    => array(
  244.                                                     "type"  => $this->inheritedOverridenAttributes["src"],
  245.                                                     "value" => $data["inherited"]
  246.                                                 )
  247.                                             );
  248.             $this->xmlwriter->addElement("inherited", "", $attribs);
  249.         }
  250.         
  251.         if (isset($data["overrides"])) {
  252.             $attribs = array( 
  253.                             "src"    => array(
  254.                                                 "type"    => $this->inheritedOverridenAttributes["src"],
  255.                                                 "value"    => $data["overrides"]
  256.                                             )
  257.                             );
  258.             $this->xmlwriter->addElement("overriden", "", $attribs);                                            
  259.         }
  260.             
  261.         reset($this->docTags);
  262.         while (list($field, $tag) = each($this->docTags))
  263.             if (isset($data[$field]))
  264.                 $this->xmlwriter->addElement($tag, $data[$field], "");
  265.             
  266.         $this->xmlwriter->endElement("doc", true);
  267.     } // end func docXML
  268.  
  269.     /**
  270.     * Adds <global> container to the xml document.
  271.     * 
  272.     * @param    array
  273.     */
  274.     function globalsXML($globals) {
  275.     
  276.         reset($globals);
  277.         while (list($k, $data) = each($globals)) {
  278.             $attribs = $this->getAttributes($data, $this->globalAttributes);
  279.             $this->xmlwriter->addElement("global", (isset($data["desc"])) ? $data["desc"] : "", $attribs);
  280.         }
  281.         
  282.     } // end func globalsXML
  283.     
  284.     /**
  285.     * Adds <throws> container to the xml document.
  286.     * 
  287.     * @param    array
  288.     */
  289.     function throwsXML($exceptions) {
  290.         
  291.         reset($exceptions);
  292.         while (list($k, $exception) = each($exceptions)) 
  293.             $this->xmlwriter->addElement("throws", $exception, "", true);
  294.         
  295.     } // end func throwsXML
  296.     
  297.     /**
  298.     * Adds <return> container to the xml document.
  299.     * 
  300.     * @param    array
  301.     */
  302.     function returnXML($return) {
  303.  
  304.         $desc = "";    
  305.         
  306.         if (is_array($return)) {
  307.         
  308.             if (isset($return["desc"])) {
  309.                 $desc = $return["desc"];
  310.                 unset($return["desc"]);
  311.             }
  312.             $attribs = $this->getAttributes($return, $this->returnAttributes);
  313.             
  314.         } else {
  315.         
  316.             $attribs["type"] = array( "type"    => "CDATA", "value"    => $return );
  317.             
  318.         }
  319.         
  320.         $this->xmlwriter->addElement("return", $desc, $attribs);
  321.         
  322.     } // end func returnXML    
  323.     
  324.     /**
  325.     * Adds <parameter> container to the xml document.
  326.     * 
  327.     * @param    array
  328.     */
  329.     function paramsXML($params) {
  330.     
  331.         reset($params);
  332.         while (list($k, $data) = each($params)) {
  333.             $attribs = $this->getAttributes($data, $this->paramAttributes);
  334.             $this->xmlwriter->addElement("parameter", (isset($data["desc"])) ? $data["desc"] : "", $attribs);
  335.         }
  336.  
  337.     } // end func paramsXML
  338.     
  339.     /**
  340.     * Adds <author> container to the xml document.
  341.     *
  342.     * @param    array
  343.     */
  344.     function authorXML($authors) {
  345.         
  346.         reset($authors);
  347.         while (list($k, $data) = each($authors)) {
  348.             
  349.             $attribs = array();
  350.             
  351.             if (isset($data["mail"]))
  352.                 $attribs = array(
  353.                                     "email"    => array(
  354.                                                         "type"  => $this->authorAttributes["email"],
  355.                                                         "value" => $data["mail"]
  356.                                                     )
  357.                                 );
  358.             $this->xmlwriter->addElement("author",$data["name"], $attribs);
  359.                                                                             
  360.         }
  361.             
  362.     } // end func authorXML
  363.     
  364.     /**
  365.     * Adds <link> container to the xml document.
  366.     *
  367.     * @param    array
  368.     */
  369.     function linkXML($links) {
  370.         
  371.         reset($links);
  372.         while (list($k, $data) = each($links)) {
  373.         
  374.             $attribs = array(
  375.                                 "url"    => array(
  376.                                                     "type"  => $this->linkAttributes["url"],
  377.                                                     "value" => $data["url"]
  378.                                                 )
  379.                             );
  380.             $this->xmlwriter->addElement("link",  (isset($data["desc"])) ? $data["desc"] : "", $attribs);                                                
  381.             
  382.         }
  383.         
  384.     } // end func linkXML
  385.     
  386.     /**
  387.     * Adds <see> container to the xml document.
  388.     * 
  389.     * @param    array
  390.     */
  391.     function seeXML($see) {
  392.         
  393.         reset($see);
  394.         while (list($type, $data) = each($see)) {
  395.             
  396.             reset($data);
  397.             while (list($k, $data2) = each($data)) {
  398.             
  399.                 $attribs = array(
  400.                                 "type"    => array(
  401.                                                     "type"  => $this->seeAttributes["type"],
  402.                                                     "value" => strtolower($type)
  403.                                                 )
  404.                             );
  405.                 if (isset($data2["group"]))
  406.                     $attribs["group"] = array(
  407.                                                 "type"  => $this->seeAttributes["group"],
  408.                                                 "value" => $data2["group"]
  409.                                             );
  410.                                                                     
  411.                 $this->xmlwriter->addElement("see", $data2["name"], $attribs);
  412.                 
  413.             }
  414.                                                         
  415.         }
  416.         
  417.     } // end func SeeXML
  418.  
  419. } // end class PhpdocXMLDocumentExporter
  420. ?>